home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / trick_or_suite.swf / scripts / DefineSprite_85 / frame_21 / DoAction.as
Encoding:
Text File  |  2011-08-19  |  90.0 KB  |  1,963 lines

  1. var ┬º\x01┬º = 0;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 0)
  6.    {
  7.       set("\x01",eval("\x01") + 384);
  8.       ┬º┬ºpush(true);
  9.    }
  10.    else
  11.    {
  12.       if(eval("\x01") == 454)
  13.       {
  14.          set("\x01",eval("\x01") + 339);
  15.          break;
  16.       }
  17.       if(eval("\x01") == 924)
  18.       {
  19.          set("\x01",eval("\x01") - 734);
  20.          stop();
  21.          break;
  22.       }
  23.       if(eval("\x01") == 451)
  24.       {
  25.          set("\x01",eval("\x01") - 68);
  26.       }
  27.       else
  28.       {
  29.          if(eval("\x01") == 720)
  30.          {
  31.             set("\x01",eval("\x01") - 533);
  32.             loop1:
  33.             while(true)
  34.             {
  35.                set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  36.                while(true)
  37.                {
  38.                   if(eval("\x01") == 348)
  39.                   {
  40.                      set("\x01",eval("\x01") + 402);
  41.                      ┬º┬ºpush(true);
  42.                      continue;
  43.                   }
  44.                   if(eval("\x01") == 276)
  45.                   {
  46.                      set("\x01",eval("\x01") + 498);
  47.                      continue;
  48.                   }
  49.                   if(eval("\x01") == 809)
  50.                   {
  51.                      set("\x01",eval("\x01") - 21);
  52.                      gotoAndStop(1);
  53.                      break loop0;
  54.                   }
  55.                   if(eval("\x01") == 428)
  56.                   {
  57.                      set("\x01",eval("\x01") + 510);
  58.                      ┬º┬ºpush(true);
  59.                      continue;
  60.                   }
  61.                   if(eval("\x01") == 50)
  62.                   {
  63.                      break loop1;
  64.                   }
  65.                   if(eval("\x01") == 471)
  66.                   {
  67.                      set("\x01",eval("\x01") + 122);
  68.                      break loop0;
  69.                   }
  70.                   if(eval("\x01") == 757)
  71.                   {
  72.                      set("\x01",eval("\x01") + 14);
  73.                      continue;
  74.                   }
  75.                   if(eval("\x01") == 893)
  76.                   {
  77.                      set("\x01",eval("\x01") - 465);
  78.                      continue;
  79.                   }
  80.                   if(eval("\x01") == 819)
  81.                   {
  82.                      set("\x01",eval("\x01") - 62);
  83.                      while(true)
  84.                      {
  85.                         if(eval("\x01") == 810)
  86.                         {
  87.                            set("\x01",eval("\x01") + 59);
  88.                         }
  89.                         else if(eval("\x01") == 379)
  90.                         {
  91.                            set("\x01",eval("\x01") - 175);
  92.                         }
  93.                         else
  94.                         {
  95.                            if(eval("\x01") == 211)
  96.                            {
  97.                               set("\x01",eval("\x01") - 211);
  98.                               break loop0;
  99.                            }
  100.                            if(eval("\x01") == 590)
  101.                            {
  102.                               set("\x01",eval("\x01") - 1);
  103.                               if(┬º┬ºpop())
  104.                               {
  105.                                  set("\x01",eval("\x01") + 35);
  106.                               }
  107.                            }
  108.                            else if(eval("\x01") == 651)
  109.                            {
  110.                               set("\x01",eval("\x01") - 181);
  111.                            }
  112.                            else
  113.                            {
  114.                               if(eval("\x01") == 927)
  115.                               {
  116.                                  set("\x01",eval("\x01") - 550);
  117.                                  break loop0;
  118.                               }
  119.                               if(eval("\x01") == 27)
  120.                               {
  121.                                  set("\x01",eval("\x01") + 900);
  122.                                  if(┬º┬ºpop())
  123.                                  {
  124.                                     set("\x01",eval("\x01") - 550);
  125.                                  }
  126.                               }
  127.                               else
  128.                               {
  129.                                  if(eval("\x01") == 105)
  130.                                  {
  131.                                     set("\x01",eval("\x01") + 1);
  132.                                     break loop0;
  133.                                  }
  134.                                  if(eval("\x01") == 477)
  135.                                  {
  136.                                     set("\x01",eval("\x01") - 423);
  137.                                     ┬º┬ºpush(true);
  138.                                  }
  139.                                  else if(eval("\x01") == 869)
  140.                                  {
  141.                                     set("\x01",eval("\x01") + 86);
  142.                                     ┬º┬ºpush(true);
  143.                                  }
  144.                                  else if(eval("\x01") == 955)
  145.                                  {
  146.                                     set("\x01",eval("\x01") - 519);
  147.                                     if(┬º┬ºpop())
  148.                                     {
  149.                                        set("\x01",eval("\x01") + 521);
  150.                                     }
  151.                                  }
  152.                                  else if(eval("\x01") == 957)
  153.                                  {
  154.                                     set("\x01",eval("\x01") - 487);
  155.                                  }
  156.                                  else if(eval("\x01") == 377)
  157.                                  {
  158.                                     set("\x01",eval("\x01") + 45);
  159.                                  }
  160.                                  else if(eval("\x01") == 771)
  161.                                  {
  162.                                     set("\x01",eval("\x01") - 537);
  163.                                  }
  164.                                  else
  165.                                  {
  166.                                     if(eval("\x01") != 809)
  167.                                     {
  168.                                        if(eval("\x01") == 946)
  169.                                        {
  170.                                           set("\x01",eval("\x01") - 39);
  171.                                        }
  172.                                        break loop0;
  173.                                     }
  174.                                     set("\x01",eval("\x01") + 137);
  175.                                     if(┬º┬ºpop())
  176.                                     {
  177.                                        set("\x01",eval("\x01") - 39);
  178.                                     }
  179.                                  }
  180.                               }
  181.                            }
  182.                         }
  183.                         while(true)
  184.                         {
  185.                            if(eval("\x01") == 63)
  186.                            {
  187.                               set("\x01",eval("\x01") + 527);
  188.                               ┬º┬ºpush(true);
  189.                            }
  190.                            else
  191.                            {
  192.                               if(eval("\x01") == 161)
  193.                               {
  194.                                  set("\x01",eval("\x01") - 69);
  195.                                  break loop0;
  196.                               }
  197.                               if(eval("\x01") == 722)
  198.                               {
  199.                                  set("\x01",eval("\x01") - 636);
  200.                                  ┬º┬ºpush(true);
  201.                               }
  202.                               else
  203.                               {
  204.                                  if(eval("\x01") == 660)
  205.                                  {
  206.                                     set("\x01",eval("\x01") - 377);
  207.                                     break loop0;
  208.                                  }
  209.                                  if(eval("\x01") == 540)
  210.                                  {
  211.                                     set("\x01",eval("\x01") - 329);
  212.                                     stop();
  213.                                     break loop0;
  214.                                  }
  215.                                  if(eval("\x01") == 616)
  216.                                  {
  217.                                     set("\x01",eval("\x01") + 148);
  218.                                     ┬º┬ºpush(true);
  219.                                  }
  220.                                  else if(eval("\x01") == 54)
  221.                                  {
  222.                                     set("\x01",eval("\x01") + 51);
  223.                                     if(┬º┬ºpop())
  224.                                     {
  225.                                        set("\x01",eval("\x01") + 1);
  226.                                     }
  227.                                  }
  228.                                  else if(eval("\x01") == 204)
  229.                                  {
  230.                                     set("\x01",eval("\x01") + 365);
  231.                                     ┬º┬ºpush(true);
  232.                                  }
  233.                                  else if(eval("\x01") == 907)
  234.                                  {
  235.                                     set("\x01",eval("\x01") - 367);
  236.                                  }
  237.                                  else if(eval("\x01") == 609)
  238.                                  {
  239.                                     set("\x01",eval("\x01") + 113);
  240.                                  }
  241.                                  else if(eval("\x01") == 569)
  242.                                  {
  243.                                     set("\x01",eval("\x01") + 152);
  244.                                     if(┬º┬ºpop())
  245.                                     {
  246.                                        set("\x01",eval("\x01") - 641);
  247.                                     }
  248.                                  }
  249.                                  else if(eval("\x01") == 422)
  250.                                  {
  251.                                     set("\x01",eval("\x01") + 404);
  252.                                     ┬º┬ºpush(true);
  253.                                  }
  254.                                  else if(eval("\x01") == 968)
  255.                                  {
  256.                                     set("\x01",eval("\x01") - 352);
  257.                                  }
  258.                                  else if(eval("\x01") == 624)
  259.                                  {
  260.                                     set("\x01",eval("\x01") - 420);
  261.                                  }
  262.                                  else if(eval("\x01") == 764)
  263.                                  {
  264.                                     set("\x01",eval("\x01") - 104);
  265.                                     if(┬º┬ºpop())
  266.                                     {
  267.                                        set("\x01",eval("\x01") - 377);
  268.                                     }
  269.                                  }
  270.                                  else if(eval("\x01") == 283)
  271.                                  {
  272.                                     set("\x01",eval("\x01") + 194);
  273.                                  }
  274.                                  else
  275.                                  {
  276.                                     if(eval("\x01") == 589)
  277.                                     {
  278.                                        set("\x01",eval("\x01") + 35);
  279.                                        break loop0;
  280.                                     }
  281.                                     if(eval("\x01") == 131)
  282.                                     {
  283.                                        set("\x01",eval("\x01") + 346);
  284.                                     }
  285.                                     else if(eval("\x01") == 86)
  286.                                     {
  287.                                        set("\x01",eval("\x01") + 172);
  288.                                        if(┬º┬ºpop())
  289.                                        {
  290.                                           set("\x01",eval("\x01") + 552);
  291.                                        }
  292.                                     }
  293.                                     else
  294.                                     {
  295.                                        if(eval("\x01") == 721)
  296.                                        {
  297.                                           set("\x01",eval("\x01") - 641);
  298.                                           break loop0;
  299.                                        }
  300.                                        if(eval("\x01") == 826)
  301.                                        {
  302.                                           set("\x01",eval("\x01") - 665);
  303.                                           if(┬º┬ºpop())
  304.                                           {
  305.                                              set("\x01",eval("\x01") - 69);
  306.                                           }
  307.                                        }
  308.                                        else if(eval("\x01") == 977)
  309.                                        {
  310.                                           set("\x01",eval("\x01") - 108);
  311.                                        }
  312.                                        else if(eval("\x01") == 374)
  313.                                        {
  314.                                           set("\x01",eval("\x01") + 48);
  315.                                        }
  316.                                        else if(eval("\x01") == 106)
  317.                                        {
  318.                                           set("\x01",eval("\x01") + 616);
  319.                                        }
  320.                                        else if(eval("\x01") == 92)
  321.                                        {
  322.                                           set("\x01",eval("\x01") + 142);
  323.                                        }
  324.                                        else if(eval("\x01") == 176)
  325.                                        {
  326.                                           set("\x01",eval("\x01") + 364);
  327.                                        }
  328.                                        else if(eval("\x01") == 470)
  329.                                        {
  330.                                           set("\x01",eval("\x01") - 443);
  331.                                           ┬º┬ºpush(true);
  332.                                        }
  333.                                        else if(eval("\x01") == 80)
  334.                                        {
  335.                                           set("\x01",eval("\x01") + 536);
  336.                                        }
  337.                                        else
  338.                                        {
  339.                                           if(eval("\x01") == 436)
  340.                                           {
  341.                                              set("\x01",eval("\x01") + 521);
  342.                                              break loop0;
  343.                                           }
  344.                                           if(eval("\x01") == 258)
  345.                                           {
  346.                                              set("\x01",eval("\x01") + 552);
  347.                                              break loop0;
  348.                                           }
  349.                                           if(eval("\x01") != 234)
  350.                                           {
  351.                                              break;
  352.                                           }
  353.                                           set("\x01",eval("\x01") + 575);
  354.                                           ┬º┬ºpush(true);
  355.                                        }
  356.                                     }
  357.                                  }
  358.                               }
  359.                            }
  360.                         }
  361.                      }
  362.                   }
  363.                   else
  364.                   {
  365.                      if(eval("\x01") == 250)
  366.                      {
  367.                         set("\x01",eval("\x01") + 436);
  368.                         continue;
  369.                      }
  370.                      if(eval("\x01") == 934)
  371.                      {
  372.                         set("\x01",eval("\x01") - 916);
  373.                         while(true)
  374.                         {
  375.                            set(┬º┬ºpop(),┬º┬ºpop());
  376.                            ┬º┬ºpush(true);
  377.                            addr1270:
  378.                            while(true)
  379.                            {
  380.                               if(eval("\x01") == 932)
  381.                               {
  382.                                  set("\x01",eval("\x01") - 698);
  383.                                  ┬º┬ºpush(true);
  384.                                  continue;
  385.                               }
  386.                               if(eval("\x01") == 572)
  387.                               {
  388.                                  set("\x01",eval("\x01") + 106);
  389.                                  if(┬º┬ºpop())
  390.                                  {
  391.                                     set("\x01",eval("\x01") + 87);
  392.                                  }
  393.                                  continue;
  394.                               }
  395.                               if(eval("\x01") == 659)
  396.                               {
  397.                                  set("\x01",eval("\x01") - 524);
  398.                                  continue;
  399.                               }
  400.                               if(eval("\x01") == 848)
  401.                               {
  402.                                  break;
  403.                               }
  404.                               if(eval("\x01") == 991)
  405.                               {
  406.                                  set("\x01",eval("\x01") - 729);
  407.                                  continue;
  408.                               }
  409.                               if(eval("\x01") == 434)
  410.                               {
  411.                                  set("\x01",eval("\x01") - 409);
  412.                                  break loop0;
  413.                               }
  414.                               if(eval("\x01") == 915)
  415.                               {
  416.                                  set("\x01",eval("\x01") - 599);
  417.                                  continue;
  418.                               }
  419.                               if(eval("\x01") == 770)
  420.                               {
  421.                                  set("\x01",eval("\x01") + 99);
  422.                                  continue;
  423.                               }
  424.                               if(eval("\x01") == 253)
  425.                               {
  426.                                  set("\x01",eval("\x01") + 662);
  427.                                  break loop0;
  428.                               }
  429.                               if(eval("\x01") == 582)
  430.                               {
  431.                                  set("\x01",eval("\x01") + 85);
  432.                                  ┬º┬ºpush(true);
  433.                                  continue;
  434.                               }
  435.                               if(eval("\x01") == 678)
  436.                               {
  437.                                  set("\x01",eval("\x01") + 87);
  438.                                  break loop0;
  439.                               }
  440.                            }
  441.                         }
  442.                         addr1482:
  443.                         set("\x01",eval("\x01") - 172);
  444.                         ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  445.                         while(true)
  446.                         {
  447.                            if(eval("\x01") == 650)
  448.                            {
  449.                               set("\x01",eval("\x01") - 547);
  450.                            }
  451.                            else
  452.                            {
  453.                               if(eval("\x01") == 259)
  454.                               {
  455.                                  set("\x01",eval("\x01") + 726);
  456.                                  break loop0;
  457.                               }
  458.                               if(eval("\x01") == 883)
  459.                               {
  460.                                  set("\x01",eval("\x01") + 81);
  461.                               }
  462.                               else if(eval("\x01") == 824)
  463.                               {
  464.                                  set("\x01",eval("\x01") - 164);
  465.                               }
  466.                               else if(eval("\x01") == 846)
  467.                               {
  468.                                  set("\x01",eval("\x01") - 683);
  469.                               }
  470.                               else
  471.                               {
  472.                                  if(eval("\x01") == 743)
  473.                                  {
  474.                                     set("\x01",eval("\x01") - 353);
  475.                                     prevFrame();
  476.                                     break loop0;
  477.                                  }
  478.                                  if(eval("\x01") == 467)
  479.                                  {
  480.                                     set("\x01",eval("\x01") + 44);
  481.                                     if(┬º┬ºpop())
  482.                                     {
  483.                                        set("\x01",eval("\x01") - 331);
  484.                                     }
  485.                                  }
  486.                                  else
  487.                                  {
  488.                                     if(eval("\x01") == 262)
  489.                                     {
  490.                                        set("\x01",eval("\x01") + 621);
  491.                                        break loop0;
  492.                                     }
  493.                                     if(eval("\x01") == 108)
  494.                                     {
  495.                                        set("\x01",eval("\x01") + 503);
  496.                                        if(┬º┬ºpop())
  497.                                        {
  498.                                           set("\x01",eval("\x01") + 35);
  499.                                        }
  500.                                     }
  501.                                     else if(eval("\x01") == 291)
  502.                                     {
  503.                                        set("\x01",eval("\x01") + 70);
  504.                                        ┬º┬ºpush(true);
  505.                                     }
  506.                                     else if(eval("\x01") == 170)
  507.                                     {
  508.                                        set("\x01",eval("\x01") + 459);
  509.                                     }
  510.                                     else
  511.                                     {
  512.                                        if(eval("\x01") == 431)
  513.                                        {
  514.                                           set("\x01",eval("\x01") - 201);
  515.                                           break loop0;
  516.                                        }
  517.                                        if(eval("\x01") == 466)
  518.                                        {
  519.                                           set("\x01",eval("\x01") - 175);
  520.                                        }
  521.                                        else if(eval("\x01") == 267)
  522.                                        {
  523.                                           set("\x01",eval("\x01") - 210);
  524.                                        }
  525.                                        else if(eval("\x01") == 390)
  526.                                        {
  527.                                           set("\x01",eval("\x01") + 270);
  528.                                        }
  529.                                        else if(eval("\x01") == 133)
  530.                                        {
  531.                                           set("\x01",eval("\x01") + 126);
  532.                                           if(┬º┬ºpop())
  533.                                           {
  534.                                              set("\x01",eval("\x01") + 726);
  535.                                           }
  536.                                        }
  537.                                        else if(eval("\x01") == 978)
  538.                                        {
  539.                                           set("\x01",eval("\x01") - 547);
  540.                                           if(┬º┬ºpop())
  541.                                           {
  542.                                              set("\x01",eval("\x01") - 201);
  543.                                           }
  544.                                        }
  545.                                        else if(eval("\x01") == 998)
  546.                                        {
  547.                                           set("\x01",eval("\x01") - 707);
  548.                                        }
  549.                                        else
  550.                                        {
  551.                                           if(eval("\x01") == 362)
  552.                                           {
  553.                                              set("\x01",eval("\x01") + 636);
  554.                                              ┬º┬ºpush(┬º┬ºpop() and typeof ┬º┬ºpop());
  555.                                              break loop0;
  556.                                           }
  557.                                           if(eval("\x01") == 712)
  558.                                           {
  559.                                              set("\x01",eval("\x01") - 350);
  560.                                              if(┬º┬ºpop())
  561.                                              {
  562.                                                 set("\x01",eval("\x01") + 636);
  563.                                              }
  564.                                           }
  565.                                           else if(eval("\x01") == 646)
  566.                                           {
  567.                                              set("\x01",eval("\x01") - 589);
  568.                                           }
  569.                                           else if(eval("\x01") == 660)
  570.                                           {
  571.                                              set("\x01",eval("\x01") + 52);
  572.                                              ┬º┬ºpush(true);
  573.                                           }
  574.                                           else if(eval("\x01") == 985)
  575.                                           {
  576.                                              set("\x01",eval("\x01") - 882);
  577.                                           }
  578.                                           else if(eval("\x01") == 103)
  579.                                           {
  580.                                              set("\x01",eval("\x01") + 5);
  581.                                              ┬º┬ºpush(true);
  582.                                           }
  583.                                           else if(eval("\x01") == 230)
  584.                                           {
  585.                                              set("\x01",eval("\x01") + 495);
  586.                                           }
  587.                                           else
  588.                                           {
  589.                                              if(eval("\x01") == 611)
  590.                                              {
  591.                                                 set("\x01",eval("\x01") + 35);
  592.                                                 ┬º┬ºpush(┬º┬ºpop()(┬º┬ºpop() / ┬º┬ºpop()));
  593.                                                 break loop0;
  594.                                              }
  595.                                              if(eval("\x01") != 510)
  596.                                              {
  597.                                                 if(eval("\x01") == 87)
  598.                                                 {
  599.                                                    set("\x01",eval("\x01") - 87);
  600.                                                 }
  601.                                                 break loop0;
  602.                                              }
  603.                                              set("\x01",eval("\x01") + 215);
  604.                                           }
  605.                                        }
  606.                                     }
  607.                                  }
  608.                               }
  609.                            }
  610.                            while(true)
  611.                            {
  612.                               if(eval("\x01") == 347)
  613.                               {
  614.                                  set("\x01",eval("\x01") - 9);
  615.                                  ┬º┬ºpush(true);
  616.                               }
  617.                               else if(eval("\x01") == 629)
  618.                               {
  619.                                  set("\x01",eval("\x01") - 496);
  620.                                  ┬º┬ºpush(true);
  621.                               }
  622.                               else if(eval("\x01") == 964)
  623.                               {
  624.                                  set("\x01",eval("\x01") - 866);
  625.                                  ┬º┬ºpush(true);
  626.                               }
  627.                               else if(eval("\x01") == 682)
  628.                               {
  629.                                  set("\x01",eval("\x01") + 282);
  630.                               }
  631.                               else
  632.                               {
  633.                                  if(eval("\x01") == 511)
  634.                                  {
  635.                                     set("\x01",eval("\x01") - 331);
  636.                                     break loop0;
  637.                                  }
  638.                                  if(eval("\x01") == 98)
  639.                                  {
  640.                                     set("\x01",eval("\x01") - 2);
  641.                                     if(┬º┬ºpop())
  642.                                     {
  643.                                        set("\x01",eval("\x01") + 343);
  644.                                     }
  645.                                  }
  646.                                  else
  647.                                  {
  648.                                     if(eval("\x01") == 725)
  649.                                     {
  650.                                        set("\x01",eval("\x01") - 638);
  651.                                        gotoAndStop(1);
  652.                                        break loop0;
  653.                                     }
  654.                                     if(eval("\x01") == 180)
  655.                                     {
  656.                                        set("\x01",eval("\x01") + 449);
  657.                                     }
  658.                                     else if(eval("\x01") == 163)
  659.                                     {
  660.                                        set("\x01",eval("\x01") + 304);
  661.                                        ┬º┬ºpush(true);
  662.                                     }
  663.                                     else if(eval("\x01") == 338)
  664.                                     {
  665.                                        set("\x01",eval("\x01") + 405);
  666.                                        if(┬º┬ºpop())
  667.                                        {
  668.                                           set("\x01",eval("\x01") - 353);
  669.                                        }
  670.                                     }
  671.                                     else if(eval("\x01") == 361)
  672.                                     {
  673.                                        set("\x01",eval("\x01") - 99);
  674.                                        if(┬º┬ºpop())
  675.                                        {
  676.                                           set("\x01",eval("\x01") + 621);
  677.                                        }
  678.                                     }
  679.                                     else
  680.                                     {
  681.                                        if(eval("\x01") == 96)
  682.                                        {
  683.                                           set("\x01",eval("\x01") + 343);
  684.                                           break loop0;
  685.                                        }
  686.                                        if(eval("\x01") == 439)
  687.                                        {
  688.                                           set("\x01",eval("\x01") - 276);
  689.                                        }
  690.                                        else
  691.                                        {
  692.                                           if(eval("\x01") != 57)
  693.                                           {
  694.                                              break;
  695.                                           }
  696.                                           set("\x01",eval("\x01") + 921);
  697.                                           ┬º┬ºpush(true);
  698.                                        }
  699.                                     }
  700.                                  }
  701.                               }
  702.                            }
  703.                         }
  704.                      }
  705.                      else
  706.                      {
  707.                         if(eval("\x01") == 464)
  708.                         {
  709.                            set("\x01",eval("\x01") + 186);
  710.                            if(┬º┬ºpop())
  711.                            {
  712.                               set("\x01",eval("\x01") - 392);
  713.                            }
  714.                            continue;
  715.                         }
  716.                         if(eval("\x01") == 26)
  717.                         {
  718.                            set("\x01",eval("\x01") + 402);
  719.                            continue;
  720.                         }
  721.                         if(eval("\x01") == 168)
  722.                         {
  723.                            set("\x01",eval("\x01") - 118);
  724.                            if(┬º┬ºpop())
  725.                            {
  726.                               set("\x01",eval("\x01") + 843);
  727.                            }
  728.                            continue;
  729.                         }
  730.                         if(eval("\x01") == 883)
  731.                         {
  732.                            set("\x01",eval("\x01") - 556);
  733.                            ┬º┬ºpush(true);
  734.                            continue;
  735.                         }
  736.                         if(eval("\x01") == 845)
  737.                         {
  738.                            set("\x01",eval("\x01") - 677);
  739.                            ┬º┬ºpush(true);
  740.                            continue;
  741.                         }
  742.                         if(eval("\x01") == 337)
  743.                         {
  744.                            set("\x01",eval("\x01") + 596);
  745.                            if(┬º┬ºpop())
  746.                            {
  747.                               set("\x01",eval("\x01") - 683);
  748.                            }
  749.                            continue;
  750.                         }
  751.                         if(eval("\x01") == 771)
  752.                         {
  753.                            set("\x01",eval("\x01") - 434);
  754.                            ┬º┬ºpush(true);
  755.                            continue;
  756.                         }
  757.                         if(eval("\x01") == 232)
  758.                         {
  759.                            set("\x01",eval("\x01") + 613);
  760.                            continue;
  761.                         }
  762.                         if(eval("\x01") == 938)
  763.                         {
  764.                            set("\x01",eval("\x01") - 467);
  765.                            if(┬º┬ºpop())
  766.                            {
  767.                               set("\x01",eval("\x01") + 122);
  768.                            }
  769.                            continue;
  770.                         }
  771.                         if(eval("\x01") == 327)
  772.                         {
  773.                            set("\x01",eval("\x01") - 91);
  774.                            if(┬º┬ºpop())
  775.                            {
  776.                               set("\x01",eval("\x01") + 587);
  777.                            }
  778.                            continue;
  779.                         }
  780.                         if(eval("\x01") == 933)
  781.                         {
  782.                            set("\x01",eval("\x01") - 683);
  783.                            stop();
  784.                            break loop0;
  785.                         }
  786.                         if(eval("\x01") == 166)
  787.                         {
  788.                            set("\x01",eval("\x01") + 4);
  789.                            continue;
  790.                         }
  791.                         if(eval("\x01") == 750)
  792.                         {
  793.                            set("\x01",eval("\x01") + 68);
  794.                            if(┬º┬ºpop())
  795.                            {
  796.                               set("\x01",eval("\x01") - 135);
  797.                            }
  798.                            continue;
  799.                         }
  800.                         if(eval("\x01") == 502)
  801.                         {
  802.                            set("\x01",eval("\x01") + 307);
  803.                            continue;
  804.                         }
  805.                         if(eval("\x01") == 154)
  806.                         {
  807.                            set("\x01",eval("\x01") + 521);
  808.                            if(┬º┬ºpop())
  809.                            {
  810.                               set("\x01",eval("\x01") - 89);
  811.                            }
  812.                            continue;
  813.                         }
  814.                         if(eval("\x01") == 624)
  815.                         {
  816.                            set("\x01",eval("\x01") + 39);
  817.                            ┬º┬ºpush(true);
  818.                            continue;
  819.                         }
  820.                         if(eval("\x01") == 258)
  821.                         {
  822.                            set("\x01",eval("\x01") + 587);
  823.                            continue;
  824.                         }
  825.                         if(eval("\x01") == 586)
  826.                         {
  827.                            set("\x01",eval("\x01") + 188);
  828.                            continue;
  829.                         }
  830.                         if(eval("\x01") == 126)
  831.                         {
  832.                            break;
  833.                         }
  834.                         if(eval("\x01") == 774)
  835.                         {
  836.                            set("\x01",eval("\x01") - 199);
  837.                            ┬º┬ºpush(true);
  838.                            continue;
  839.                         }
  840.                         if(eval("\x01") == 593)
  841.                         {
  842.                            set("\x01",eval("\x01") + 216);
  843.                            continue;
  844.                         }
  845.                         if(eval("\x01") == 818)
  846.                         {
  847.                            set("\x01",eval("\x01") - 135);
  848.                            ┬º┬ºpush(┬º┬ºpop() === ┬º┬ºpop());
  849.                            break loop0;
  850.                         }
  851.                         if(eval("\x01") == 575)
  852.                         {
  853.                            set("\x01",eval("\x01") + 244);
  854.                            if(┬º┬ºpop())
  855.                            {
  856.                               set("\x01",eval("\x01") - 62);
  857.                            }
  858.                            continue;
  859.                         }
  860.                         if(eval("\x01") == 788)
  861.                         {
  862.                            set("\x01",eval("\x01") - 788);
  863.                            break loop0;
  864.                         }
  865.                         if(eval("\x01") == 663)
  866.                         {
  867.                            set("\x01",eval("\x01") + 271);
  868.                            if(┬º┬ºpop())
  869.                            {
  870.                               set("\x01",eval("\x01") - 916);
  871.                            }
  872.                            continue;
  873.                         }
  874.                         if(eval("\x01") == 236)
  875.                         {
  876.                            set("\x01",eval("\x01") + 587);
  877.                            ifFrameLoaded(56890)
  878.                            {
  879.                               loop0:
  880.                               while(true)
  881.                               {
  882.                                  set("\x01",eval("\x01") + 208);
  883.                                  while(true)
  884.                                  {
  885.                                     if(eval("\x01") == 350)
  886.                                     {
  887.                                        set("\x01",eval("\x01") - 72);
  888.                                        ┬º┬ºpush(true);
  889.                                     }
  890.                                     else if(eval("\x01") == 581)
  891.                                     {
  892.                                        set("\x01",eval("\x01") - 439);
  893.                                     }
  894.                                     else
  895.                                     {
  896.                                        if(eval("\x01") == 92)
  897.                                        {
  898.                                           set("\x01",eval("\x01") + 489);
  899.                                           break;
  900.                                        }
  901.                                        if(eval("\x01") == 690)
  902.                                        {
  903.                                           set("\x01",eval("\x01") + 8);
  904.                                        }
  905.                                        else if(eval("\x01") == 253)
  906.                                        {
  907.                                           set("\x01",eval("\x01") - 161);
  908.                                           if(┬º┬ºpop())
  909.                                           {
  910.                                              set("\x01",eval("\x01") + 489);
  911.                                           }
  912.                                        }
  913.                                        else if(eval("\x01") == 153)
  914.                                        {
  915.                                           set("\x01",eval("\x01") + 386);
  916.                                           ┬º┬ºpush(true);
  917.                                        }
  918.                                        else if(eval("\x01") == 987)
  919.                                        {
  920.                                           set("\x01",eval("\x01") - 834);
  921.                                        }
  922.                                        else
  923.                                        {
  924.                                           if(eval("\x01") == 308)
  925.                                           {
  926.                                              set("\x01",eval("\x01") + 382);
  927.                                              break;
  928.                                           }
  929.                                           if(eval("\x01") == 875)
  930.                                           {
  931.                                              set("\x01",eval("\x01") - 849);
  932.                                              ┬º┬ºpush(true);
  933.                                           }
  934.                                           else if(eval("\x01") == 896)
  935.                                           {
  936.                                              set("\x01",eval("\x01") - 399);
  937.                                           }
  938.                                           else if(eval("\x01") == 278)
  939.                                           {
  940.                                              set("\x01",eval("\x01") + 30);
  941.                                              if(┬º┬ºpop())
  942.                                              {
  943.                                                 set("\x01",eval("\x01") + 382);
  944.                                              }
  945.                                           }
  946.                                           else if(eval("\x01") == 846)
  947.                                           {
  948.                                              set("\x01",eval("\x01") + 29);
  949.                                           }
  950.                                           else
  951.                                           {
  952.                                              if(eval("\x01") == 289)
  953.                                              {
  954.                                                 continue loop0;
  955.                                              }
  956.                                              if(eval("\x01") == 424)
  957.                                              {
  958.                                                 set("\x01",eval("\x01") + 274);
  959.                                              }
  960.                                              else if(eval("\x01") == 622)
  961.                                              {
  962.                                                 set("\x01",eval("\x01") - 369);
  963.                                                 ┬º┬ºpush(true);
  964.                                              }
  965.                                              else if(eval("\x01") == 26)
  966.                                              {
  967.                                                 set("\x01",eval("\x01") + 481);
  968.                                                 if(┬º┬ºpop())
  969.                                                 {
  970.                                                    set("\x01",eval("\x01") - 353);
  971.                                                 }
  972.                                              }
  973.                                              else
  974.                                              {
  975.                                                 if(eval("\x01") != 155)
  976.                                                 {
  977.                                                    if(eval("\x01") == 698)
  978.                                                    {
  979.                                                       ┬º┬ºpush("\x01");
  980.                                                    }
  981.                                                    break;
  982.                                                 }
  983.                                                 set("\x01",eval("\x01") - 13);
  984.                                              }
  985.                                           }
  986.                                        }
  987.                                     }
  988.                                  }
  989.                               }
  990.                            }
  991.                            set(┬º┬ºpop(),eval("\x01") + 225);
  992.                            ┬º┬ºpush(true);
  993.                            while(true)
  994.                            {
  995.                               if(eval("\x01") == 350)
  996.                               {
  997.                                  set("\x01",eval("\x01") - 72);
  998.                                  ┬º┬ºpush(true);
  999.                               }
  1000.                               else if(eval("\x01") == 581)
  1001.                               {
  1002.                                  set("\x01",eval("\x01") - 439);
  1003.                               }
  1004.                               else
  1005.                               {
  1006.                                  if(eval("\x01") == 92)
  1007.                                  {
  1008.                                     set("\x01",eval("\x01") + 489);
  1009.                                     break loop0;
  1010.                                  }
  1011.                                  if(eval("\x01") == 690)
  1012.                                  {
  1013.                                     set("\x01",eval("\x01") + 8);
  1014.                                  }
  1015.                                  else if(eval("\x01") == 253)
  1016.                                  {
  1017.                                     set("\x01",eval("\x01") - 161);
  1018.                                     if(┬º┬ºpop())
  1019.                                     {
  1020.                                        set("\x01",eval("\x01") + 489);
  1021.                                     }
  1022.                                  }
  1023.                                  else if(eval("\x01") == 153)
  1024.                                  {
  1025.                                     set("\x01",eval("\x01") + 386);
  1026.                                     ┬º┬ºpush(true);
  1027.                                  }
  1028.                                  else if(eval("\x01") == 987)
  1029.                                  {
  1030.                                     set("\x01",eval("\x01") - 834);
  1031.                                  }
  1032.                                  else
  1033.                                  {
  1034.                                     if(eval("\x01") == 308)
  1035.                                     {
  1036.                                        addr140:
  1037.                                        set("\x01",eval("\x01") + 382);
  1038.                                        break loop0;
  1039.                                     }
  1040.                                     if(eval("\x01") == 875)
  1041.                                     {
  1042.                                        set("\x01",eval("\x01") - 849);
  1043.                                        ┬º┬ºpush(true);
  1044.                                     }
  1045.                                     else if(eval("\x01") == 896)
  1046.                                     {
  1047.                                        set("\x01",eval("\x01") - 399);
  1048.                                     }
  1049.                                     else if(eval("\x01") == 278)
  1050.                                     {
  1051.                                        set("\x01",eval("\x01") + 30);
  1052.                                        if(┬º┬ºpop())
  1053.                                        {
  1054.                                           set("\x01",eval("\x01") + 382);
  1055.                                        }
  1056.                                     }
  1057.                                     else if(eval("\x01") == 846)
  1058.                                     {
  1059.                                        set("\x01",eval("\x01") + 29);
  1060.                                     }
  1061.                                     else
  1062.                                     {
  1063.                                        if(eval("\x01") == 289)
  1064.                                        {
  1065.                                           break;
  1066.                                        }
  1067.                                        if(eval("\x01") == 424)
  1068.                                        {
  1069.                                           set("\x01",eval("\x01") + 274);
  1070.                                        }
  1071.                                        else if(eval("\x01") == 622)
  1072.                                        {
  1073.                                           set("\x01",eval("\x01") - 369);
  1074.                                           ┬º┬ºpush(true);
  1075.                                        }
  1076.                                        else if(eval("\x01") == 26)
  1077.                                        {
  1078.                                           set("\x01",eval("\x01") + 481);
  1079.                                           if(┬º┬ºpop())
  1080.                                           {
  1081.                                              set("\x01",eval("\x01") - 353);
  1082.                                           }
  1083.                                        }
  1084.                                        else if(eval("\x01") == 155)
  1085.                                        {
  1086.                                           set("\x01",eval("\x01") - 13);
  1087.                                        }
  1088.                                        else if(eval("\x01") == 698)
  1089.                                        {
  1090.                                           set("\x01",eval("\x01") + 225);
  1091.                                           ┬º┬ºpush(true);
  1092.                                        }
  1093.                                        else if(eval("\x01") == 154)
  1094.                                        {
  1095.                                           set("\x01",eval("\x01") + 468);
  1096.                                        }
  1097.                                        else if(eval("\x01") == 894)
  1098.                                        {
  1099.                                           set("\x01",eval("\x01") - 19);
  1100.                                        }
  1101.                                        else
  1102.                                        {
  1103.                                           if(eval("\x01") == 142)
  1104.                                           {
  1105.                                              set("\x01",eval("\x01") + 183);
  1106.                                              if(!_root.gameInPlay)
  1107.                                              {
  1108.                                                 stop();
  1109.                                              }
  1110.                                              break loop0;
  1111.                                           }
  1112.                                           if(eval("\x01") == 923)
  1113.                                           {
  1114.                                              set("\x01",eval("\x01") - 266);
  1115.                                              if(┬º┬ºpop())
  1116.                                              {
  1117.                                                 set("\x01",eval("\x01") - 448);
  1118.                                              }
  1119.                                           }
  1120.                                           else
  1121.                                           {
  1122.                                              if(eval("\x01") == 397)
  1123.                                              {
  1124.                                                 set("\x01",eval("\x01") - 108);
  1125.                                                 break loop0;
  1126.                                              }
  1127.                                              if(eval("\x01") == 539)
  1128.                                              {
  1129.                                                 set("\x01",eval("\x01") - 142);
  1130.                                                 if(┬º┬ºpop())
  1131.                                                 {
  1132.                                                    set("\x01",eval("\x01") - 108);
  1133.                                                 }
  1134.                                              }
  1135.                                              else if(eval("\x01") == 497)
  1136.                                              {
  1137.                                                 set("\x01",eval("\x01") + 320);
  1138.                                                 ┬º┬ºpush(true);
  1139.                                              }
  1140.                                              else
  1141.                                              {
  1142.                                                 if(eval("\x01") == 678)
  1143.                                                 {
  1144.                                                    set("\x01",eval("\x01") + 216);
  1145.                                                    break loop0;
  1146.                                                 }
  1147.                                                 if(eval("\x01") == 817)
  1148.                                                 {
  1149.                                                    set("\x01",eval("\x01") - 139);
  1150.                                                    if(┬º┬ºpop())
  1151.                                                    {
  1152.                                                       set("\x01",eval("\x01") + 216);
  1153.                                                    }
  1154.                                                 }
  1155.                                                 else
  1156.                                                 {
  1157.                                                    if(eval("\x01") == 507)
  1158.                                                    {
  1159.                                                       set("\x01",eval("\x01") - 353);
  1160.                                                       break loop0;
  1161.                                                    }
  1162.                                                    if(eval("\x01") == 325)
  1163.                                                    {
  1164.                                                       set("\x01",eval("\x01") - 325);
  1165.                                                       break loop0;
  1166.                                                    }
  1167.                                                    if(eval("\x01") == 209)
  1168.                                                    {
  1169.                                                       set("\x01",eval("\x01") - 56);
  1170.                                                    }
  1171.                                                    else
  1172.                                                    {
  1173.                                                       if(eval("\x01") == 657)
  1174.                                                       {
  1175.                                                          set("\x01",eval("\x01") - 448);
  1176.                                                          break loop0;
  1177.                                                       }
  1178.                                                       if(eval("\x01") != 934)
  1179.                                                       {
  1180.                                                          break loop0;
  1181.                                                       }
  1182.                                                       set("\x01",eval("\x01") - 312);
  1183.                                                    }
  1184.                                                 }
  1185.                                              }
  1186.                                           }
  1187.                                        }
  1188.                                     }
  1189.                                  }
  1190.                               }
  1191.                            }
  1192.                            while(true)
  1193.                            {
  1194.                               set("\x01",eval("\x01") + 208);
  1195.                               ┬º┬ºgoto(addr29);
  1196.                            }
  1197.                            addr29:
  1198.                            ┬º┬ºgoto(addr140);
  1199.                         }
  1200.                         else
  1201.                         {
  1202.                            if(eval("\x01") == 227)
  1203.                            {
  1204.                               set("\x01",eval("\x01") + 397);
  1205.                               continue;
  1206.                            }
  1207.                            if(eval("\x01") == 18)
  1208.                            {
  1209.                               set("\x01",eval("\x01") + 609);
  1210.                               continue;
  1211.                            }
  1212.                            if(eval("\x01") == 73)
  1213.                            {
  1214.                               set("\x01",eval("\x01") - 27);
  1215.                               if(┬º┬ºpop())
  1216.                               {
  1217.                                  set("\x01",eval("\x01") + 347);
  1218.                               }
  1219.                               continue;
  1220.                            }
  1221.                            if(eval("\x01") == 650)
  1222.                            {
  1223.                               set("\x01",eval("\x01") - 392);
  1224.                               set("\x01",eval("\x01") - 364);
  1225.                               break loop0;
  1226.                            }
  1227.                            if(eval("\x01") == 8)
  1228.                            {
  1229.                               set("\x01",eval("\x01") + 619);
  1230.                               continue;
  1231.                            }
  1232.                            if(eval("\x01") == 823)
  1233.                            {
  1234.                               set("\x01",eval("\x01") - 653);
  1235.                               continue;
  1236.                            }
  1237.                            if(eval("\x01") == 683)
  1238.                            {
  1239.                               set("\x01",eval("\x01") + 200);
  1240.                               continue;
  1241.                            }
  1242.                            if(eval("\x01") == 83)
  1243.                            {
  1244.                               set("\x01",eval("\x01") + 800);
  1245.                               continue;
  1246.                            }
  1247.                            if(eval("\x01") != 675)
  1248.                            {
  1249.                               if(eval("\x01") == 170)
  1250.                               {
  1251.                                  set("\x01",eval("\x01") - 16);
  1252.                                  ┬º┬ºpush(true);
  1253.                               }
  1254.                               else if(eval("\x01") == 627)
  1255.                               {
  1256.                                  set("\x01",eval("\x01") - 163);
  1257.                                  ┬º┬ºpush(true);
  1258.                               }
  1259.                               else if(eval("\x01") == 338)
  1260.                               {
  1261.                                  set("\x01",eval("\x01") + 348);
  1262.                               }
  1263.                               else if(eval("\x01") == 393)
  1264.                               {
  1265.                                  set("\x01",eval("\x01") + 231);
  1266.                               }
  1267.                               else
  1268.                               {
  1269.                                  if(eval("\x01") != 686)
  1270.                                  {
  1271.                                     if(eval("\x01") == 46)
  1272.                                     {
  1273.                                        set("\x01",eval("\x01") + 347);
  1274.                                     }
  1275.                                     break loop0;
  1276.                                  }
  1277.                                  set("\x01",eval("\x01") - 613);
  1278.                                  ┬º┬ºpush(true);
  1279.                               }
  1280.                               continue;
  1281.                            }
  1282.                            set("\x01",eval("\x01") - 89);
  1283.                         }
  1284.                      }
  1285.                      while(true)
  1286.                      {
  1287.                         if(eval("\x01") == 394)
  1288.                         {
  1289.                            set("\x01",eval("\x01") - 259);
  1290.                            ┬º┬ºgoto(addr1270);
  1291.                         }
  1292.                         else if(eval("\x01") == 556)
  1293.                         {
  1294.                            set("\x01",eval("\x01") + 292);
  1295.                            ┬º┬ºgoto(addr1270);
  1296.                         }
  1297.                         else if(eval("\x01") == 117)
  1298.                         {
  1299.                            set("\x01",eval("\x01") + 317);
  1300.                            if(┬º┬ºpop())
  1301.                            {
  1302.                               set("\x01",eval("\x01") - 409);
  1303.                            }
  1304.                            ┬º┬ºgoto(addr1270);
  1305.                         }
  1306.                         else if(eval("\x01") != 444)
  1307.                         {
  1308.                            if(eval("\x01") == 608)
  1309.                            {
  1310.                               set("\x01",eval("\x01") + 283);
  1311.                            }
  1312.                            else
  1313.                            {
  1314.                               if(eval("\x01") == 200)
  1315.                               {
  1316.                                  set("\x01",eval("\x01") + 477);
  1317.                                  break loop0;
  1318.                               }
  1319.                               if(eval("\x01") == 731)
  1320.                               {
  1321.                                  set("\x01",eval("\x01") + 37);
  1322.                                  if(┬º┬ºpop())
  1323.                                  {
  1324.                                     set("\x01",eval("\x01") + 91);
  1325.                                  }
  1326.                               }
  1327.                               else if(eval("\x01") == 687)
  1328.                               {
  1329.                                  set("\x01",eval("\x01") - 373);
  1330.                               }
  1331.                               else if(eval("\x01") == 677)
  1332.                               {
  1333.                                  set("\x01",eval("\x01") + 142);
  1334.                               }
  1335.                               else if(eval("\x01") == 891)
  1336.                               {
  1337.                                  set("\x01",eval("\x01") - 319);
  1338.                                  ┬º┬ºpush(true);
  1339.                               }
  1340.                               else if(eval("\x01") == 914)
  1341.                               {
  1342.                                  set("\x01",eval("\x01") - 661);
  1343.                                  if(┬º┬ºpop())
  1344.                                  {
  1345.                                     set("\x01",eval("\x01") + 662);
  1346.                                  }
  1347.                               }
  1348.                               else
  1349.                               {
  1350.                                  if(eval("\x01") == 128)
  1351.                                  {
  1352.                                     set("\x01",eval("\x01") + 863);
  1353.                                     break loop0;
  1354.                                  }
  1355.                                  if(eval("\x01") == 314)
  1356.                                  {
  1357.                                     set("\x01",eval("\x01") + 600);
  1358.                                     ┬º┬ºpush(true);
  1359.                                  }
  1360.                                  else if(eval("\x01") == 316)
  1361.                                  {
  1362.                                     set("\x01",eval("\x01") + 235);
  1363.                                     ┬º┬ºpush(true);
  1364.                                  }
  1365.                                  else if(eval("\x01") == 381)
  1366.                                  {
  1367.                                     set("\x01",eval("\x01") - 119);
  1368.                                  }
  1369.                                  else
  1370.                                  {
  1371.                                     if(eval("\x01") == 724)
  1372.                                     {
  1373.                                        set("\x01",eval("\x01") - 65);
  1374.                                        break loop0;
  1375.                                     }
  1376.                                     if(eval("\x01") == 765)
  1377.                                     {
  1378.                                        set("\x01",eval("\x01") + 137);
  1379.                                     }
  1380.                                     else
  1381.                                     {
  1382.                                        if(eval("\x01") == 797)
  1383.                                        {
  1384.                                           set("\x01",eval("\x01") - 27);
  1385.                                           break loop0;
  1386.                                        }
  1387.                                        if(eval("\x01") == 768)
  1388.                                        {
  1389.                                           set("\x01",eval("\x01") + 91);
  1390.                                           ┬º┬ºpush(chr(┬º┬ºpop() === ┬º┬ºpop() % ┬º┬ºpop()));
  1391.                                           break loop0;
  1392.                                        }
  1393.                                        if(eval("\x01") == 272)
  1394.                                        {
  1395.                                           set("\x01",eval("\x01") + 576);
  1396.                                        }
  1397.                                        else if(eval("\x01") == 309)
  1398.                                        {
  1399.                                           set("\x01",eval("\x01") + 135);
  1400.                                           if(┬º┬ºpop())
  1401.                                           {
  1402.                                              set("\x01",eval("\x01") - 172);
  1403.                                           }
  1404.                                        }
  1405.                                        else if(eval("\x01") == 219)
  1406.                                        {
  1407.                                           set("\x01",eval("\x01") + 578);
  1408.                                           if(┬º┬ºpop())
  1409.                                           {
  1410.                                              set("\x01",eval("\x01") - 27);
  1411.                                           }
  1412.                                        }
  1413.                                        else if(eval("\x01") == 664)
  1414.                                        {
  1415.                                           set("\x01",eval("\x01") + 238);
  1416.                                        }
  1417.                                        else if(eval("\x01") == 963)
  1418.                                        {
  1419.                                           set("\x01",eval("\x01") - 144);
  1420.                                        }
  1421.                                        else if(eval("\x01") == 622)
  1422.                                        {
  1423.                                           set("\x01",eval("\x01") - 306);
  1424.                                        }
  1425.                                        else if(eval("\x01") == 902)
  1426.                                        {
  1427.                                           set("\x01",eval("\x01") - 683);
  1428.                                           ┬º┬ºpush(true);
  1429.                                        }
  1430.                                        else if(eval("\x01") == 804)
  1431.                                        {
  1432.                                           set("\x01",eval("\x01") + 65);
  1433.                                        }
  1434.                                        else if(eval("\x01") == 859)
  1435.                                        {
  1436.                                           set("\x01",eval("\x01") - 277);
  1437.                                        }
  1438.                                        else if(eval("\x01") == 383)
  1439.                                        {
  1440.                                           set("\x01",eval("\x01") - 183);
  1441.                                           if(┬º┬ºpop())
  1442.                                           {
  1443.                                              set("\x01",eval("\x01") + 477);
  1444.                                           }
  1445.                                        }
  1446.                                        else if(eval("\x01") == 262)
  1447.                                        {
  1448.                                           set("\x01",eval("\x01") + 121);
  1449.                                           ┬º┬ºpush(true);
  1450.                                        }
  1451.                                        else if(eval("\x01") == 85)
  1452.                                        {
  1453.                                           set("\x01",eval("\x01") + 497);
  1454.                                        }
  1455.                                        else if(eval("\x01") == 819)
  1456.                                        {
  1457.                                           set("\x01",eval("\x01") - 702);
  1458.                                           ┬º┬ºpush(true);
  1459.                                        }
  1460.                                        else if(eval("\x01") == 551)
  1461.                                        {
  1462.                                           set("\x01",eval("\x01") + 173);
  1463.                                           if(┬º┬ºpop())
  1464.                                           {
  1465.                                              set("\x01",eval("\x01") - 65);
  1466.                                           }
  1467.                                        }
  1468.                                        else if(eval("\x01") == 135)
  1469.                                        {
  1470.                                           set("\x01",eval("\x01") + 174);
  1471.                                           ┬º┬ºpush(true);
  1472.                                        }
  1473.                                        else if(eval("\x01") == 255)
  1474.                                        {
  1475.                                           set("\x01",eval("\x01") + 59);
  1476.                                        }
  1477.                                        else if(eval("\x01") == 667)
  1478.                                        {
  1479.                                           set("\x01",eval("\x01") - 539);
  1480.                                           if(┬º┬ºpop())
  1481.                                           {
  1482.                                              set("\x01",eval("\x01") + 863);
  1483.                                           }
  1484.                                        }
  1485.                                        else
  1486.                                        {
  1487.                                           if(eval("\x01") == 869)
  1488.                                           {
  1489.                                              set("\x01",eval("\x01") - 735);
  1490.                                              stop();
  1491.                                              break loop0;
  1492.                                           }
  1493.                                           if(eval("\x01") == 25)
  1494.                                           {
  1495.                                              set("\x01",eval("\x01") + 866);
  1496.                                           }
  1497.                                           else
  1498.                                           {
  1499.                                              if(eval("\x01") == 134)
  1500.                                              {
  1501.                                                 set("\x01",eval("\x01") - 134);
  1502.                                                 break loop0;
  1503.                                              }
  1504.                                              if(eval("\x01") == 211)
  1505.                                              {
  1506.                                                 set("\x01",eval("\x01") + 44);
  1507.                                                 ┬º┬ºpush(getProperty(┬º┬ºpop(), _X));
  1508.                                                 break loop0;
  1509.                                              }
  1510.                                              if(eval("\x01") != 234)
  1511.                                              {
  1512.                                                 break loop0;
  1513.                                              }
  1514.                                              set("\x01",eval("\x01") - 23);
  1515.                                              if(┬º┬ºpop())
  1516.                                              {
  1517.                                                 set("\x01",eval("\x01") + 44);
  1518.                                              }
  1519.                                           }
  1520.                                        }
  1521.                                     }
  1522.                                  }
  1523.                               }
  1524.                            }
  1525.                            ┬º┬ºgoto(addr1270);
  1526.                         }
  1527.                         ┬º┬ºgoto(addr1482);
  1528.                      }
  1529.                   }
  1530.                }
  1531.             }
  1532.             set("\x01",eval("\x01") + 843);
  1533.             loop12:
  1534.             while(true)
  1535.             {
  1536.                set(┬º┬ºpop(),eval(┬º┬ºpop()) + 536);
  1537.                if(┬º┬ºpop())
  1538.                {
  1539.                   set("\x01",eval("\x01") - 740);
  1540.                }
  1541.                while(true)
  1542.                {
  1543.                   if(eval("\x01") == 244)
  1544.                   {
  1545.                      set("\x01",eval("\x01") + 290);
  1546.                      ┬º┬ºpush(true);
  1547.                   }
  1548.                   else if(eval("\x01") == 534)
  1549.                   {
  1550.                      set("\x01",eval("\x01") + 347);
  1551.                      if(┬º┬ºpop())
  1552.                      {
  1553.                         set("\x01",eval("\x01") - 44);
  1554.                      }
  1555.                   }
  1556.                   else if(eval("\x01") == 635)
  1557.                   {
  1558.                      set("\x01",eval("\x01") - 64);
  1559.                   }
  1560.                   else if(eval("\x01") == 73)
  1561.                   {
  1562.                      set("\x01",eval("\x01") + 222);
  1563.                   }
  1564.                   else if(eval("\x01") == 952)
  1565.                   {
  1566.                      set("\x01",eval("\x01") - 828);
  1567.                   }
  1568.                   else if(eval("\x01") == 653)
  1569.                   {
  1570.                      set("\x01",eval("\x01") - 358);
  1571.                   }
  1572.                   else if(eval("\x01") == 54)
  1573.                   {
  1574.                      set("\x01",eval("\x01") + 541);
  1575.                   }
  1576.                   else
  1577.                   {
  1578.                      if(eval("\x01") == 871)
  1579.                      {
  1580.                         set("\x01",eval("\x01") - 782);
  1581.                         break loop0;
  1582.                      }
  1583.                      if(eval("\x01") == 411)
  1584.                      {
  1585.                         break;
  1586.                      }
  1587.                      if(eval("\x01") == 89)
  1588.                      {
  1589.                         set("\x01",eval("\x01") + 863);
  1590.                      }
  1591.                      else
  1592.                      {
  1593.                         if(eval("\x01") == 947)
  1594.                         {
  1595.                            break loop12;
  1596.                         }
  1597.                         if(eval("\x01") == 295)
  1598.                         {
  1599.                            set("\x01",eval("\x01") - 284);
  1600.                            ┬º┬ºpush(true);
  1601.                         }
  1602.                         else if(eval("\x01") == 560)
  1603.                         {
  1604.                            set("\x01",eval("\x01") + 392);
  1605.                         }
  1606.                         else
  1607.                         {
  1608.                            if(eval("\x01") == 72)
  1609.                            {
  1610.                               set("\x01",eval("\x01") + 581);
  1611.                               break loop0;
  1612.                            }
  1613.                            if(eval("\x01") == 11)
  1614.                            {
  1615.                               set("\x01",eval("\x01") + 860);
  1616.                               if(┬º┬ºpop())
  1617.                               {
  1618.                                  set("\x01",eval("\x01") - 782);
  1619.                               }
  1620.                            }
  1621.                            else
  1622.                            {
  1623.                               if(eval("\x01") == 881)
  1624.                               {
  1625.                                  set("\x01",eval("\x01") - 44);
  1626.                                  break loop0;
  1627.                               }
  1628.                               if(eval("\x01") == 571)
  1629.                               {
  1630.                                  set("\x01",eval("\x01") - 160);
  1631.                                  ┬º┬ºpush(true);
  1632.                               }
  1633.                               else if(eval("\x01") == 207)
  1634.                               {
  1635.                                  set("\x01",eval("\x01") + 388);
  1636.                               }
  1637.                               else if(eval("\x01") == 837)
  1638.                               {
  1639.                                  set("\x01",eval("\x01") - 266);
  1640.                               }
  1641.                               else if(eval("\x01") == 595)
  1642.                               {
  1643.                                  set("\x01",eval("\x01") + 371);
  1644.                                  ┬º┬ºpush(true);
  1645.                               }
  1646.                               else
  1647.                               {
  1648.                                  if(eval("\x01") != 966)
  1649.                                  {
  1650.                                     if(eval("\x01") == 124)
  1651.                                     {
  1652.                                        set("\x01",eval("\x01") + 219);
  1653.                                        var ┬º{invalid_utf8=191}o{invalid_utf8=235}{invalid_utf8=153}{invalid_utf8=227}\x02┬º = eval("{invalid_utf8=129}z@JZ")["\x1b{invalid_utf8=178}]wCB<{invalid_utf8=241}"](eval("{invalid_utf8=129}z@JZ")["{invalid_utf8=188}{invalid_utf8=246}"],eval("{invalid_utf8=129}z@JZ")["{invalid_utf8=241}%7{invalid_utf8=220}{invalid_utf8=230}"]);
  1654.                                        var ┬º{invalid_utf8=187}{invalid_utf8=179}{invalid_utf8=149}l\x03┬º = eval("{invalid_utf8=191}o{invalid_utf8=235}{invalid_utf8=153}{invalid_utf8=227}\x02");
  1655.                                        break loop0;
  1656.                                     }
  1657.                                     if(eval("\x01") == 343)
  1658.                                     {
  1659.                                        set("\x01",eval("\x01") - 343);
  1660.                                     }
  1661.                                     break loop0;
  1662.                                  }
  1663.                                  set("\x01",eval("\x01") - 894);
  1664.                                  if(┬º┬ºpop())
  1665.                                  {
  1666.                                     set("\x01",eval("\x01") + 581);
  1667.                                  }
  1668.                               }
  1669.                            }
  1670.                         }
  1671.                      }
  1672.                   }
  1673.                }
  1674.             }
  1675.             set("\x01",eval("\x01") - 740);
  1676.             tellTarget(new ┬º┬ºpop()[┬º┬ºpop()]())
  1677.             {
  1678.                break;
  1679.             }
  1680.          }
  1681.          if(eval("\x01") == 120)
  1682.          {
  1683.             set("\x01",eval("\x01") + 587);
  1684.             if(┬º┬ºpop())
  1685.             {
  1686.                set("\x01",eval("\x01") - 357);
  1687.             }
  1688.          }
  1689.          else
  1690.          {
  1691.             if(eval("\x01") == 645)
  1692.             {
  1693.                set("\x01",eval("\x01") - 563);
  1694.                break;
  1695.             }
  1696.             if(eval("\x01") == 836)
  1697.             {
  1698.                set("\x01",eval("\x01") - 334);
  1699.             }
  1700.             else
  1701.             {
  1702.                if(eval("\x01") == 818)
  1703.                {
  1704.                   set("\x01",eval("\x01") - 367);
  1705.                   break;
  1706.                }
  1707.                if(eval("\x01") == 205)
  1708.                {
  1709.                   set("\x01",eval("\x01") + 776);
  1710.                   ┬º┬ºpush(true);
  1711.                }
  1712.                else if(eval("\x01") == 319)
  1713.                {
  1714.                   set("\x01",eval("\x01") + 292);
  1715.                   ┬º┬ºpush(true);
  1716.                }
  1717.                else if(eval("\x01") == 593)
  1718.                {
  1719.                   set("\x01",eval("\x01") - 91);
  1720.                }
  1721.                else
  1722.                {
  1723.                   if(eval("\x01") == 970)
  1724.                   {
  1725.                      set("\x01",eval("\x01") - 377);
  1726.                      break;
  1727.                   }
  1728.                   if(eval("\x01") == 25)
  1729.                   {
  1730.                      set("\x01",eval("\x01") + 26);
  1731.                   }
  1732.                   else if(eval("\x01") == 485)
  1733.                   {
  1734.                      set("\x01",eval("\x01") - 102);
  1735.                   }
  1736.                   else if(eval("\x01") == 640)
  1737.                   {
  1738.                      set("\x01",eval("\x01") - 407);
  1739.                   }
  1740.                   else if(eval("\x01") == 233)
  1741.                   {
  1742.                      set("\x01",eval("\x01") - 113);
  1743.                      ┬º┬ºpush(true);
  1744.                   }
  1745.                   else if(eval("\x01") == 383)
  1746.                   {
  1747.                      set("\x01",eval("\x01") + 256);
  1748.                      ┬º┬ºpush(true);
  1749.                   }
  1750.                   else if(eval("\x01") == 683)
  1751.                   {
  1752.                      set("\x01",eval("\x01") - 450);
  1753.                   }
  1754.                   else
  1755.                   {
  1756.                      if(eval("\x01") == 824)
  1757.                      {
  1758.                         set("\x01",eval("\x01") - 141);
  1759.                         break;
  1760.                      }
  1761.                      if(eval("\x01") == 204)
  1762.                      {
  1763.                         set("\x01",eval("\x01") + 115);
  1764.                      }
  1765.                      else if(eval("\x01") == 300)
  1766.                      {
  1767.                         set("\x01",eval("\x01") + 524);
  1768.                         if(┬º┬ºpop())
  1769.                         {
  1770.                            set("\x01",eval("\x01") - 141);
  1771.                         }
  1772.                      }
  1773.                      else if(eval("\x01") == 518)
  1774.                      {
  1775.                         set("\x01",eval("\x01") + 452);
  1776.                         if(┬º┬ºpop())
  1777.                         {
  1778.                            set("\x01",eval("\x01") - 377);
  1779.                         }
  1780.                      }
  1781.                      else if(eval("\x01") == 365)
  1782.                      {
  1783.                         set("\x01",eval("\x01") + 559);
  1784.                         if(┬º┬ºpop())
  1785.                         {
  1786.                            set("\x01",eval("\x01") - 734);
  1787.                         }
  1788.                      }
  1789.                      else
  1790.                      {
  1791.                         if(eval("\x01") == 67)
  1792.                         {
  1793.                            set("\x01",eval("\x01") + 168);
  1794.                            eval(┬º┬ºconstant(4))[┬º┬ºconstant(5)](eval(┬º┬ºconstant(2))[┬º┬ºconstant(3)]((eval("1{invalid_utf8=133}0%") - eval("{invalid_utf8=228}2{invalid_utf8=142}")) / eval("1{invalid_utf8=133}0%") * 100));
  1795.                            ┬º{invalid_utf8=228}2{invalid_utf8=142}┬º--;
  1796.                            break;
  1797.                         }
  1798.                         if(eval("\x01") == 190)
  1799.                         {
  1800.                            set("\x01",eval("\x01") + 784);
  1801.                         }
  1802.                         else if(eval("\x01") == 187)
  1803.                         {
  1804.                            set("\x01",eval("\x01") - 136);
  1805.                         }
  1806.                         else if(eval("\x01") == 111)
  1807.                         {
  1808.                            set("\x01",eval("\x01") + 628);
  1809.                         }
  1810.                         else if(eval("\x01") == 234)
  1811.                         {
  1812.                            set("\x01",eval("\x01") + 284);
  1813.                            ┬º┬ºpush(true);
  1814.                         }
  1815.                         else if(eval("\x01") == 739)
  1816.                         {
  1817.                            set("\x01",eval("\x01") - 439);
  1818.                            ┬º┬ºpush(true);
  1819.                         }
  1820.                         else if(eval("\x01") == 372)
  1821.                         {
  1822.                            set("\x01",eval("\x01") - 167);
  1823.                         }
  1824.                         else
  1825.                         {
  1826.                            if(eval("\x01") == 757)
  1827.                            {
  1828.                               set("\x01",eval("\x01") - 7);
  1829.                               break;
  1830.                            }
  1831.                            if(eval("\x01") == 459)
  1832.                            {
  1833.                               set("\x01",eval("\x01") - 225);
  1834.                            }
  1835.                            else if(eval("\x01") == 384)
  1836.                            {
  1837.                               set("\x01",eval("\x01") + 604);
  1838.                               if(┬º┬ºpop())
  1839.                               {
  1840.                                  set("\x01",eval("\x01") - 877);
  1841.                               }
  1842.                            }
  1843.                            else if(eval("\x01") == 502)
  1844.                            {
  1845.                               set("\x01",eval("\x01") - 137);
  1846.                               ┬º┬ºpush(true);
  1847.                            }
  1848.                            else if(eval("\x01") == 152)
  1849.                            {
  1850.                               set("\x01",eval("\x01") + 605);
  1851.                               if(┬º┬ºpop())
  1852.                               {
  1853.                                  set("\x01",eval("\x01") - 7);
  1854.                               }
  1855.                            }
  1856.                            else if(eval("\x01") == 639)
  1857.                            {
  1858.                               set("\x01",eval("\x01") + 6);
  1859.                               if(┬º┬ºpop())
  1860.                               {
  1861.                                  set("\x01",eval("\x01") - 563);
  1862.                               }
  1863.                            }
  1864.                            else
  1865.                            {
  1866.                               if(eval("\x01") == 988)
  1867.                               {
  1868.                                  set("\x01",eval("\x01") - 877);
  1869.                                  break;
  1870.                               }
  1871.                               if(eval("\x01") == 750)
  1872.                               {
  1873.                                  set("\x01",eval("\x01") - 356);
  1874.                               }
  1875.                               else
  1876.                               {
  1877.                                  if(eval("\x01") == 707)
  1878.                                  {
  1879.                                     set("\x01",eval("\x01") - 357);
  1880.                                     break;
  1881.                                  }
  1882.                                  if(eval("\x01") == 793)
  1883.                                  {
  1884.                                     set("\x01",eval("\x01") - 588);
  1885.                                  }
  1886.                                  else if(eval("\x01") == 350)
  1887.                                  {
  1888.                                     set("\x01",eval("\x01") - 31);
  1889.                                  }
  1890.                                  else if(eval("\x01") == 82)
  1891.                                  {
  1892.                                     set("\x01",eval("\x01") + 152);
  1893.                                  }
  1894.                                  else if(eval("\x01") == 981)
  1895.                                  {
  1896.                                     set("\x01",eval("\x01") - 163);
  1897.                                     if(┬º┬ºpop())
  1898.                                     {
  1899.                                        set("\x01",eval("\x01") - 367);
  1900.                                     }
  1901.                                  }
  1902.                                  else if(eval("\x01") == 51)
  1903.                                  {
  1904.                                     set("\x01",eval("\x01") + 101);
  1905.                                     ┬º┬ºpush(true);
  1906.                                  }
  1907.                                  else if(eval("\x01") == 974)
  1908.                                  {
  1909.                                     set("\x01",eval("\x01") - 688);
  1910.                                     ┬º┬ºpush(true);
  1911.                                  }
  1912.                                  else if(eval("\x01") == 356)
  1913.                                  {
  1914.                                     set("\x01",eval("\x01") + 618);
  1915.                                  }
  1916.                                  else if(eval("\x01") == 286)
  1917.                                  {
  1918.                                     set("\x01",eval("\x01") + 434);
  1919.                                     if(┬º┬ºpop())
  1920.                                     {
  1921.                                        set("\x01",eval("\x01") - 533);
  1922.                                     }
  1923.                                  }
  1924.                                  else if(eval("\x01") == 211)
  1925.                                  {
  1926.                                     set("\x01",eval("\x01") + 183);
  1927.                                  }
  1928.                                  else if(eval("\x01") == 61)
  1929.                                  {
  1930.                                     set("\x01",eval("\x01") + 678);
  1931.                                  }
  1932.                                  else if(eval("\x01") == 394)
  1933.                                  {
  1934.                                     set("\x01",eval("\x01") - 327);
  1935.                                  }
  1936.                                  else
  1937.                                  {
  1938.                                     if(eval("\x01") != 611)
  1939.                                     {
  1940.                                        if(eval("\x01") == 235)
  1941.                                        {
  1942.                                           set("\x01",eval("\x01") - 235);
  1943.                                        }
  1944.                                        break;
  1945.                                     }
  1946.                                     set("\x01",eval("\x01") - 157);
  1947.                                     if(┬º┬ºpop())
  1948.                                     {
  1949.                                        set("\x01",eval("\x01") + 339);
  1950.                                     }
  1951.                                  }
  1952.                               }
  1953.                            }
  1954.                         }
  1955.                      }
  1956.                   }
  1957.                }
  1958.             }
  1959.          }
  1960.       }
  1961.    }
  1962. }
  1963.